home *** CD-ROM | disk | FTP | other *** search
/ Trading on the Edge / Trading On The Edge - CD-ROM Toolkit (Wayzata Technology)(2031)(1994).bin / pc / mac_file / vendor_d / neuralwa / nw2v50 / uio_comp.c < prev    next >
Text File  |  1993-08-23  |  8KB  |  387 lines
  1. /* uio_cmp.c */
  2. /************************************************************************
  3.  * Copyright(C) 1987-1992 NeuralWare Inc                                *
  4.  * Penn Center West, IV-227, Pittsburgh, PA 15276                       *
  5.  * Telephone: (412) 787-8222    FAX: (412) 787-8220                     *
  6.  *                                                                      *
  7.  * All rights reserved.  No part of this program may be reproduced,     *
  8.  * stored in a retrieval system, or transmitted, in any form or by any  *
  9.  * means, electronic, mechanical, photocopying, recording or otherwise  *
  10.  * without the prior written permission of the copyright owner,         *
  11.  * NeuralWare, Inc.                                                     *
  12.  *                                                                      *
  13.  *                          PROPRIETARY NOTICE                          *
  14.  *                                                                      *
  15.  * This document is the property of NeuralWare, Inc. and contains       *
  16.  * trade-secrets and other proprietary information.  The information    *
  17.  * herein is reserved as proprietary to NeuralWare, and is not to be    *
  18.  * published, reproduced, copied, disclosed, used, or reverse           *
  19.  * engineered without the express written consent of a duly authorized  *
  20.  * representative of NeuralWare.                                        *
  21.  ************************************************************************
  22.  */
  23.  
  24.  
  25. /**********************************************************************/
  26. /*                                                                    */
  27. /*    uio_comp.c - provides compatibilty with old style UserIO code   */
  28. /*    Author: John C. Fairman           October 8, 1990               */
  29. /*    Copyright 1990 by NeuralWare Inc.                               */
  30. /*                                                                    */
  31. /*    $Author   :  $                                                  */
  32. /*    $Date     :  $                                                  */
  33. /*    $Source   :  $                                                  */
  34. /*    $Revision :  $                                                  */
  35. /*    $Log      :  $                                                  */
  36. /*                                                                    */
  37. /**********************************************************************/
  38.  
  39. #define UIO_SERVER             1
  40. #define SERVER_EMULATOR_FILE   1
  41. #define HOME_FOR_COMPAT_DATA   1
  42. #include "userutl.h"
  43. #include "uio_strc.h"
  44. #include "uio_reqs.pro"
  45. #include "uio_cmds.pro"
  46.  
  47. #if defined(_MSC_VER) || defined(__TURBOC__)
  48. int UsrIO( VOID );
  49. #else
  50. int UsrIO();
  51. #endif
  52.  
  53. /*********************************************************************/
  54. /*                                                                   */
  55. /* Functions neccessary for handling the User I/O package itself.    */
  56. /*                                                                   */
  57. /*********************************************************************/
  58.  
  59. /* FUNCTION */
  60. NINT UIO_Init(file)
  61. TEXT *file;
  62. {
  63.    NINT ret_val = UIO_OK;
  64.    
  65.    return(ret_val);
  66. }
  67.  
  68.  
  69. /* */
  70. /* FUNCTION */
  71. NINT UIO_Term(process)
  72. NINT process;
  73. {
  74.    NINT ret_val = UIO_OK;
  75.    
  76.    IOCOUNT   = 0;
  77.    IOLAYER   = 0;
  78.    IOREQCDE  = RQ_TERM;
  79.    UsrIO();
  80.    ret_val   = IORTNCDE;
  81.    
  82.    return(ret_val);
  83. }
  84.  
  85.  
  86. /* FUNCTION */
  87. NINT UIO_Attention()
  88. {
  89.    NINT ret_val = UIO_OK;
  90.    
  91.    IOCOUNT   = 0;
  92.    IOLAYER   = 0;
  93.    IOREQCDE  = RQ_ATTENTION;
  94.    UsrIO();
  95.    ret_val   = IORTNCDE;
  96.    
  97.    return(ret_val);
  98. }
  99.  
  100.  
  101. /**************************************************************/
  102. /*                                                            */
  103. /*  Functions necessary for handling a learning session.      */
  104. /*                                                            */
  105. /**************************************************************/
  106.  
  107. /* FUNCTION */
  108. NINT UIO_Learn_Start()
  109. {
  110.    NINT ret_val = UIO_OK;
  111.    
  112.    IOCOUNT   = 0;
  113.    IOLAYER   = 0;
  114.    IOREQCDE  = RQ_LSTART;
  115.    UsrIO();
  116.    ret_val   = IORTNCDE;
  117.    
  118.    return(ret_val);
  119. }
  120.  
  121.  
  122. /* */
  123. /* FUNCTION */
  124. NINT UIO_Learn_Input(LayN, nPEs, Datap)
  125. NINT  LayN;
  126. NINT  nPEs;
  127. SREAL *Datap;
  128. {
  129.    NINT ret_val = UIO_OK;
  130.    
  131.    IODATA    = Datap;
  132.    IOCOUNT   = nPEs;
  133.    IOLAYER   = LayN;
  134.    IOREQCDE  = RQ_LEARNIN;
  135.    UsrIO();
  136.    ret_val   = IORTNCDE;
  137.    
  138.    return(ret_val);
  139. }
  140.  
  141.  
  142. /* FUNCTION */
  143. NINT UIO_Learn_Output(LayN, nPEs, Datap)
  144. NINT  LayN;
  145. NINT  nPEs;
  146. SREAL *Datap;
  147. {
  148.    NINT ret_val = UIO_OK;
  149.    
  150.    IODATA    = Datap;
  151.    IOCOUNT   = nPEs;
  152.    IOLAYER   = LayN;
  153.    IOREQCDE  = RQ_LEARNOUT;
  154.    UsrIO();
  155.    ret_val   = IORTNCDE;
  156.    
  157.    return(ret_val);
  158. }
  159.  
  160.  
  161. /* FUNCTION */
  162. NINT UIO_Learn_Result(LayN, nPEs, Datap)
  163. NINT  LayN;
  164. NINT  nPEs;
  165. SREAL *Datap;
  166. {
  167.    NINT ret_val = UIO_OK;
  168.    
  169.    IODATA    = Datap;
  170.    IOCOUNT   = nPEs;
  171.    IOLAYER   = LayN;
  172.    IOREQCDE  = RQ_LEARNRSLT;
  173.    UsrIO();
  174.    ret_val   = IORTNCDE;
  175.    
  176.    return(ret_val);
  177. }
  178.  
  179.  
  180. /* */
  181. /* FUNCTION */
  182. NINT UIO_Learn_End()
  183. {
  184.    NINT ret_val = UIO_OK;
  185.    
  186.    IOCOUNT   = 0;
  187.    IOLAYER   = 0;
  188.    IOREQCDE  = RQ_LEND;
  189.    UsrIO();
  190.    ret_val   = IORTNCDE;
  191.    
  192.    return(ret_val);
  193. }
  194.  
  195.  
  196. /*******************************************************************/
  197. /*                                                                 */
  198. /*  Functions necessary for handling a recall or testing session.  */
  199. /*                                                                 */
  200. /*******************************************************************/
  201.  
  202. /* FUNCTION */
  203. NINT UIO_Recall_Start()
  204. {
  205.    NINT ret_val = UIO_OK;
  206.    
  207.    IOCOUNT   = 0;
  208.    IOLAYER   = 0;
  209.    IOREQCDE  = RQ_RSTART;
  210.    UsrIO();
  211.    ret_val   = IORTNCDE;
  212.    
  213.    return(ret_val);
  214. }
  215.  
  216.  
  217. /* FUNCTION */
  218. NINT UIO_Read(LayN, nPEs, Datap)
  219. NINT  LayN;
  220. NINT  nPEs;
  221. SREAL *Datap;
  222. {
  223.    NINT ret_val = UIO_OK;
  224.    
  225.    IODATA    = Datap;
  226.    IOCOUNT   = nPEs;
  227.    IOLAYER   = LayN;
  228.    IOREQCDE  = RQ_READ;
  229.    UsrIO();
  230.    ret_val   = IORTNCDE;
  231.    
  232.    return(ret_val);
  233. }
  234.  
  235.  
  236. /* */
  237. /* FUNCTION */
  238. NINT UIO_Write(LayN, nPEs, Datap)
  239. NINT  LayN;
  240. NINT  nPEs;
  241. SREAL *Datap;
  242. {
  243.    NINT ret_val = UIO_OK;
  244.    
  245.    IODATA    = Datap;
  246.    IOCOUNT   = nPEs;
  247.    IOLAYER   = LayN;
  248.    IOREQCDE  = RQ_WRITE;
  249.    UsrIO();
  250.    ret_val   = IORTNCDE;
  251.    
  252.    return(ret_val);
  253. }
  254.  
  255.  
  256. /* FUNCTION */
  257. NINT UIO_Write_Step(LayN, nPEs, Datap)
  258. NINT  LayN;
  259. NINT  nPEs;
  260. SREAL *Datap;
  261. {
  262.    NINT ret_val = UIO_OK;
  263.    
  264.    IODATA    = Datap;
  265.    IOCOUNT   = nPEs;
  266.    IOLAYER   = LayN;
  267.    IOREQCDE  = RQ_WRSTEP;
  268.    UsrIO();
  269.    ret_val   = IORTNCDE;
  270.    
  271.    return(ret_val);
  272. }
  273.  
  274.  
  275. /* FUNCTION */
  276. NINT UIO_Recall_Test(LayN, nPEs, Datap)
  277. NINT  LayN;
  278. NINT  nPEs;
  279. SREAL *Datap;
  280. {
  281.    NINT ret_val = UIO_OK;
  282.    
  283.    IODATA    = Datap;
  284.    IOCOUNT   = nPEs;
  285.    IOLAYER   = LayN;
  286.    IOREQCDE  = RQ_RCLTST;
  287.    UsrIO();
  288.    ret_val   = IORTNCDE;
  289.    
  290.    return(ret_val);
  291. }
  292.  
  293. /* */
  294. /* FUNCTION */
  295. NINT UIO_Recall_End()
  296. {
  297.    NINT ret_val = UIO_OK;
  298.    
  299.    IOCOUNT   = 0;
  300.    IOLAYER   = 0;
  301.    IOREQCDE  = RQ_REND;
  302.    UsrIO();
  303.    ret_val   = IORTNCDE;
  304.    
  305.    return(ret_val);
  306. }
  307.  
  308.  
  309. /*****************************************************/
  310. /*                                                   */
  311. /*  Other miscelaneous functions.                    */
  312. /*                                                   */
  313. /*****************************************************/
  314.  
  315. /* FUNCTION */
  316. NINT UIO_Instrument(Instrument_id, nDataElems, DataElemp)
  317. NINT  Instrument_id;
  318. NINT  nDataElems;
  319. SREAL *DataElemp;
  320. {
  321.    NINT ret_val = UIO_OK;
  322.    
  323.    IODATA    = DataElemp;
  324.    IOCOUNT   = nDataElems;
  325.    IOLAYER   = Instrument_id;
  326.    IOREQCDE  = RQ_INSTRUM;
  327.    UsrIO();
  328.    ret_val   = IORTNCDE;
  329.    
  330.    return(ret_val);
  331. }
  332.  
  333.  
  334. /* FUNCTION */
  335. NINT UIO_ObjFunc(eoeflag, DataElemp)
  336. NINT  eoeflag;
  337. SREAL *DataElemp;
  338. {
  339.    NINT ret_val = UIO_OK;
  340.    
  341.    IODATA    = DataElemp;
  342.    IOCOUNT   = eoeflag;
  343.    IOLAYER   = 0;
  344.    IOREQCDE  = RQ_OBJFUNC;
  345.    UsrIO();
  346.    ret_val   = IORTNCDE;
  347.    
  348.    return(ret_val);
  349. }
  350.  
  351.  
  352. /* FUNCTION */
  353. NINT UIO_Rewind()
  354. {
  355.    NINT ret_val = UIO_OK;
  356.    
  357.    IOCOUNT   = 0;
  358.    IOLAYER   = 0;
  359.    IOREQCDE  = RQ_REWIND;
  360.    UsrIO();
  361.    ret_val   = IORTNCDE;
  362.    
  363.    return(ret_val);
  364. }
  365.  
  366.  
  367. /* */
  368. /* FUNCTION */
  369. NINT UIO_Explain(LayN, nPEs, Datap)
  370. NINT  LayN;
  371. NINT  nPEs;
  372. SREAL *Datap;
  373. {
  374.    NINT ret_val = UIO_OK;
  375.    
  376.    IODATA    = Datap;
  377.    IOCOUNT   = nPEs;
  378.    IOLAYER   = LayN;
  379.    IOREQCDE  = RQ_EXPLAIN;
  380.    UsrIO();
  381.    ret_val   = IORTNCDE;
  382.    
  383.    return(ret_val);
  384. }
  385.  
  386.  
  387.